Livrable 3 : Fast and Furious

Equipe 03 :
Lou Dutertre-Thouan, Louey Guinoubi, Ethan Swica, Raphaël Linard, Flavio De Barros Barbosa, Nathan Bayeul

Sommaire :

1. Introduction

• Les différentes étapes du parcours
• Les différentes forces appliquées à la voiture
• Python
• Formule de la méthode d’Euler

2. Étape 1 : Descente de la pente

• Forces et repères
• Equations du mouvement
• Calculs

2. Étape 2 : Looping

• Forces et repères
• Equations du mouvement
• Calculs

3. Étape 3 : Saut en l’air

• Forces et repères
• Equations du mouvement
• Calculs

4. Étape 4 : Piste d’arrivée

• Forces et repères
• Equations du mouvement
• Calculs

5. Circuit complet

• Schéma du circuit
• Calculs
• Résultats

6. Comparaison des valeurs obtenues

• Vitesse à la fin de la pente
• Vitesse minimale à l’entrée du looping pour le réussir
• Vitesse à la fin du looping
• Vitesse minimale à la sortie du looping pour réussir le saut
• Vitesse à la fin du circuit
• Temps effectué

7. Critiques

8. Conclusion

Introduction

Owen Shaw à proposer un défi à Dom Torreto de remporter une course de voiture sur circuit.
Ce circuit est composé de différentes étapes :

• Une piste d’élan avec une hauteur de 2m et une longueur de 31m.
• Un looping de 6 m de rayon.
• Un saut au-dessus d’un ravin de 9m de large et 1m de dénivelé négatif.
• Une piste de 10m jusqu’à l’arrivée.

Un ami de Dom Torreto, Tej Parker, membre de notre équipe doit choisir la bonne voiture pour faire gagner la course à Dom. Pour ce faire notre équipe doit procéder à une étude du circuit pour savoir quelle voiture sera la plus adaptée.

Dom Torreto aimerait remporter la course avec sa Dodge qui est sa voiture de prédilection.

Pour ce troisième livrable nous devons réaliser un rapport (et un code paramétrable) qui détaillera la résolution des équations du mouvement (de manière numérique) énoncées dans le livrable 2.

Les différentes étapes du parcours :

Étape 1 : Descente de la pente
Étape 2 : Looping
Étape 3 : Saut en l’air
Étape 4 : Piste d’arrivée

Les différentes forces appliquées à la voiture :

• Le poids $\vec P$ se définit par la formule suivante : $P = m⋅g$ avec $P = ||\vec P||$
• La réaction normale $\vec N$ : $N = ||\vec N||$
• Le frottement $\vec f$ avec le sol : $N⋅μ$
• La force moteur $\vec{Fm}$ se définit par la formule suivante : $Fm = a_m⋅m$ avec $Fm = ||\vec{Fm}||$
• L’accélération $\vec a$ : $∑\vec{F_{ext}} = m⋅\vec a$
• La portance $\vec p$ se définit par la formule suivante : $p = \frac{1}{2}⋅ρ⋅S⋅C_z⋅v^2$ avec $p = ||\vec p||$

Lexique :
$m$, la masse de la voiture (en kg) ;
$g$, la constante gravitationnelle (≈ 9.81N/kg) ;
$α$, l’angle en degrés ;
$N = ||\vec N||$ ;
$μ$, le coefficient de frottement dynamique entre la route et les pneus ;
$a_m$, l’accélération moyenne de la voiture (en m/s$^2$) ;
$ρ$, la masse volumique du fluide, ici l’air (en g/L) ;
$S$, la surface de contact (en m) ;
$C_x$, le coefficient de trainée ;
$C_z$, le coefficient de portance ;
$v$, la vitesse (en km/h) ;

Python :

Les fonctions présentées, plus tard dans ce livrable, ne fonctionneront pas sans ces variables et bibliothèques

Initialisation des variables :

Variables avec des valeurs figées :

u=0.1 #coefficient de frottement
g=9.81 #constante gravitationnelle
rho=1.293 # Masse volumique de l'air à 20°C

Dictionnaires des voitures :

Dodge={"masse":1760,"accm":5.1,"longueur":5.28,"largeur":1.95,"hauteur":1.35,"trainee":0.38}
Toyota={"masse":1615,"accm":5.4,"longueur":4.51,"largeur":1.81,"hauteur":1.27,"trainee":0.29}
Chevrolet={"masse":1498,"accm":5.3,"longueur":4.72,"largeur":1.88,"hauteur":1.3,"trainee":0.35}
Mazda={"masse":1385,"accm":5.2,"longueur":4.3,"largeur":1.75,"hauteur":1.23,"trainee":0.28}
Nissan={"masse":1540,"accm":5.8,"longueur":4.6,"largeur":1.79,"hauteur":1.36,"trainee":0.34}
Mitsubishi={"masse":1600,"accm":5,"longueur":4.51,"largeur":1.81,"hauteur":1.48,"trainee":0.28}

Importation des bibliothèques :

On importe la bibliothèque “math” pour effectuer des calculs mathématiques, ainsi que la bibliothèque “matplotlib.pyplot” pour effectuer des graphiques.

import math as m
import matplotlib.pyplot as plt

Formule de la méthode d’Euler :

On utilisera cette formule pour résoudre nos équations différentielles.

Étape 1 : Descente de la pente

Forces et Repères :

Équations du mouvement :

Projection sur l’axe $x$ :
( $y <=> \vec i$ )

$a_x = \frac{-r-f+(P*sin(α))+Fm}m$

Donc :
$a_x = \frac{-(\frac{1}2*ρ*S*C_x*v^2)-(N*µ)+(a_m*m)+(m*g*sin(α))}m =\frac{-(\frac{1}2*ρ*S*C_x*v^2)-(N*µ)}m+a_m+(g*sin(α))$

$F_{constante} = -(N*µ)+(a_m*m)+(m*g*sin(α))$

Soit une forme plus simple :
$v'_x = \frac{-(\frac{1}2*ρ*S*C_x*v^2)+F_{constante}}m$

On trouve une équation différentielle de la forme $v'+ ay^2 = b$

Projection sur l’axe $y$ :
( $y <=> \vec j$ )

$a_y = 0$
Donc : $v'_y = 0$

Alors : $N = -P*cos(a)$ qui est à réutiliser dans le calcul pour les forces constantes !

En conclusion, la vitesse de la voiture sera le résultat de l’équation différentielle de $v’_x$.

Calculs :

Calcul de l’angle $α$ :

$α = arccos(\frac{2}{31}) = 3,70°$

Code Python :

# Etape 1 pour la pente
def Pente(voiture,pas,ailerons=0,jupe = 0,booster = 0): 
# Initialisation des variables si on utilise les accessoires d'amélioration

    # Initilialisation de variables
    vitessei=0
    alpha=3.70*(m.pi/180)
    distance = 0
    t=0
    
    # Coefficient de trainée
    Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
    
    # Initialisation de variables
    mvoiture=voiture["masse"]+ailerons*30+jupe*15
    accvoiture=voiture["accm"]+((voiture["accm"]*30)/100)*booster
    
    # Forces 
    poids = (mvoiture*g*m.sin(alpha))
    k = -(1/2)*rho*(voiture["largeur"]*voiture["hauteur"])*Cx
    N = (m.cos(alpha) *mvoiture*g)
    frottement = N*u
    
    force_constante=poids-frottement
    
    # Tant qu'on arrive pas au bout de notre pente
    while not distance>=31:
        t += pas
        Ftotale = (k*vitessei**2)+force_constante
        vitessei = vitessei + ((Ftotale/mvoiture) + accvoiture)*pas
        # Réecriture de l'équation différentielle avec la méthode d'Euler
        distance += vitessei*pas
        
    vitesse_finale = vitessei
    temps_final = t 
    
    print("Le temps final pour l'étape 1 est de : "+str(temps_final))
    print("La vitesse finale pour l'étape 1 est de : "+str(vitesse_finale))
    
    return vitesse_finale,temps_final

Exemple :

En exemple, on calcule avec la Dodge qui ne dispose d’aucun équipement.

Pente(Dodge,0.0001)

Le temps final pour l'étape 1 est de :3.618100000003211
La vitesse finale pour l'étape 1 est de : 17.070908072743308

Étape 2 : Looping

Forces et Repères :

Forces appliquées :

Repères polaires :

Équations du mouvement :

Système n°1 : Bilan polaire
$\vec{OM} = L*\vec{e_r}$

En dérivant $\vec{OM}$, et en simplifiant on trouve ce résultat :
$\vec v = L*\dot θ*\vec{e_θ}$

En dérivant $\vec v$, et en simplifiant on trouve ce résultat :
$\vec a = -L*\dot θ^2*\vec{e_r}+L*\ddot θ*\vec{e_θ}$
Avec L, la distance entre le centre du looping et de la voiture.

Système n°2 : Bilan des forces appliquées à la voiture
$∑F_{ext} = m*\vec a$
$\vec r+\vec f+\vec N+\vec{Fm}+\vec P = m*\vec a$

Sur l’axe $\vec{e_r}$ puis sur l’axe $\vec{e_θ}$ :
$m*\vec a = m*\begin{pmatrix}P*cos⁡(θ)-N\\-r-f-P*sin⁡(θ)+Fm\end{pmatrix}$

Grâce à ces deux systèmes nous pouvons obtenir ces 2 équations différentielles :

1. Projection sur $\vec{e_r}$ :
   $v'_{cen} = -L*\dot θ^2 = \frac{(P*cos⁡(θ)-N)}m$
   $\dot θ^2 = \frac{-P*cos⁡(θ)+N}{m*L}$
2. Projection sur $\vec{e_θ}$ à calculer pour obtenir la vitesse :
   $v'_{tan} = \ddot θ = \frac{Fm-r-f-P*sin⁡(θ)}{m*L}$
   Avec $r = (1/2⋅ρ⋅S⋅C_x⋅v^2)$ (avec la vitesse $v=L*\dot θ$ et $P = m*g$)

Pour obtenir la normale étant donné que nous ne savons pas comment l’a calculer ici, nous devons utiliser l’équation pour $\dot θ^2$ et isoler $N$ pour l’obtenir et la réinjecter dans l’autre équation.

Ainsi nous obtenons :

$\ddot θ = \frac{(m*a)-(k*(\dot θ*L)^2)-(u*(P*cos(θ)+L*\dot θ^2*m))-(P*sin(θ))}{m*L}$

Calculs :

Code Python :

# Etape 2 pour le looping
def Looping(voiture, vitessei, pas, ailerons=0,jupe=0, booster=0):
# Initialisation des variables si on utilise les accessoires d'amélioration

    # Initialisation des listes
    x2 = [0]
    y2 = [0]
    t = [0]
    
    # Paramètres de la voiture et de l'environnement
    L = 6  # Rayon du looping
    w = [vitessei / L]  # Vitesse angulaire initiale
    theta = [0]  # Angle initial
    
    # Coefficient de trainée
    Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
    
    # Initialisation de variables
    mvoiture = voiture["masse"]+ailerons*30+jupe*15
    accvoiture = voiture["accm"]+((voiture["accm"]*30)/100)*booster
    
    # Forces
    k = (1/2)*rho*voiture["largeur"]*voiture["hauteur"]*Cx  
    P = mvoiture * g

    # Tant qu'on a pas fait le tour du cercle
    while theta[-1] < 2 * m.pi: 
        # Mise à jour du pas
        t.append(t[-1] + pas)
        nouveau_theta = theta[-1] + (pas * w[-1])
        
        # Sépération de plusieurs équations 
        Ftotale1 = -(k*(w[-1]**2)*(L**2))
        Ftotale2 = -(u*(P*m.cos(theta[-1])+L*(w[-1]**2)*mvoiture))
        Ftotale3 = -(P*m.sin(theta[-1]))
        
        # Rassemblement des équations
        FtotaleF = Ftotale1 + Ftotale2 + Ftotale3
        
        # Calcul de l'accélération angulaire
        acceleration_angulaire = (accvoiture/L) + FtotaleF/(mvoiture * L)
        
        # Calcul de la nouvelle vitesse angulaire
        nouvelle_vitesse_angulaire = w[-1] + (pas * acceleration_angulaire)
        
        # Mise à jour des listes
        theta.append(nouveau_theta)
        w.append(nouvelle_vitesse_angulaire)
        
        # Calcul en fonction de la force qui nous tire vers le bas 
        vitesse_decrochage = m.sqrt(g*L*abs(m.cos(theta[-1])))
        
        v = w[-1] * L
        
        if v < vitesse_decrochage :
            print("Decrochage")
            plt.figure()
            plt.plot(x2, y2)
            plt.xlabel("x (m)")
            plt.ylabel("y (m)")
            plt.title("Trajectoire de la voiture")
            plt.axis([-L, L, 0, 2 * L])
            plt.grid()
            plt.show()
            
            # Graphique de la vitesse
            v = [wi * L for wi in w]  
            # Reprise de toutes les valeures !
            
            plt.figure()
            plt.plot(t, v)
            plt.xlabel("Temps (s)")
            plt.ylabel("Vitesse (m/s)")
            plt.title("Vitesse en fonction du temps")
            plt.grid()
            plt.show()
            return None,None
        distance = v * pas
        
        # Gestion des coordonnées X et Y
        x2.append(x2[-1] + m.cos(nouveau_theta) * distance)
        y2.append(y2[-1] + m.sin(nouveau_theta) * distance)
    
    # Graphique de la trajectoire
    plt.figure()
    plt.plot(x2, y2,color = (1,0,1))
    plt.xlabel("x (m)")
    plt.ylabel("y (m)")
    plt.title("Trajectoire de la voiture")
    plt.axis([-L, L, 0, 2 * L])
    plt.grid()
    plt.show()
    
    # Graphique de la vitesse
    v = [wi * L for wi in w]  
    # Reprise de toutes les valeures pour la vitesse grâce à la liste w
    
    plt.plot(t, v,color = (0,0,1))
    plt.xlabel("Temps (s)")
    plt.ylabel("Vitesse (m/s)")
    plt.title("Vitesse en fonction du temps")
    plt.grid()
    plt.show()
    print("Le temps final pour l'étape 2 est de : "+str(t[-1]))
    print("La vitesse finale pour l'étape 2 est de : "+str(v[-1]))
    return v[-1], t[-1]

Graphique de la trajectoire de la voiture :

Le graphique concerne uniquement la dodge car il change selon la voiture.

Graphique de l’évolution de la vitesse de la voiture :

Le graphique concerne uniquement la dodge car il change selon la voiture.

Exemple :

En exemple, on calcule avec la Dodge qui ne dispose d’aucun équipement.

Looping(Dodge,Pente(Dodge,0.0001)[0],0.0001)

Le temps final pour l'étape 2 est de : 2.616000000001096
La vitesse finale pour l'étape 2 est de : 19.422966784313846

Calcul de la vitesse minimale à l’entrée du looping pour le franchir :

#Trouver la vitesse minimum pour effectuer le looping (ici pour la Dodge)
def trouverx():
    v=21
    bon=Looping(Dodge,v,0.001)[0] # Etape avec quelle voiture pour vérifier son minimum
    while bon!=None:
        v=v-0.001
        
        # Etape avec quelle voiture pour vérifier son minimum
        bon = Looping(Dodge,v,0.001)[0] 
        
    return v

print(trouverx())

13.525999999996484

En conclusion, chaque voiture possède une vitesse minimale différente, à l’entrée du looping pour pouvoir le franchir. La Dodge doit avoir une vitesse supérieure ou égale à 13.526 m/s pour pouvoir le franchir. Tandis que la Nissan doit posséder une vitesse supérieure ou égale à 12.313 m/s.

Étape 3 : Saut en l’air

Forces et Repères :

Équations du mouvement :

Sur l’axe $x$ :
( $x <=> \vec i$ )

$a_x = -\frac{r}m$
Donc : $v'_x = -\frac{r}m$

Équation différentielle :
Avec $r = (1/2⋅ρ⋅S⋅C_x⋅v^2)$

Sur l’axe $y$ :
( $y <=> \vec j$ )

$a_y = -g+\frac{p}m$
Donc : $v'_y = g+\frac{p}m$

Équation différentielle :
Avec $p = (1/2⋅ρ⋅S⋅C_z⋅v^2)$

Après la résolution de la vitesse $v_x$ et $v_y$, il nous restera à faire le module pour obtenir la vitesse réelle.

Calculs :

Code Python :

# Etape 3 pour le ravin
def Ravin(voiture,pas,vitessei,ailerons=0,jupe = 0):
# Initialisation des variables si on utilise les accessoires d'amélioration

    # Initialisation des listes
    X3=[0]
    Y3=[1]
    
    # Initialisation de variables
    distancex = 0
    distancey=1
    vitesseX=vitessei
    vitesseX1=vitesseX
    vitesseY=0
    t=0
    
    # Coefficient de trainée
    Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
    
    # Coefficient de portance
    Cz=0.3 +0.03*ailerons
    
    # Initialisation de variables
    mvoiture=voiture["masse"]+ailerons*30+jupe*15
    
    # Forces
    kx = -(1/2)*rho*voiture["largeur"]*voiture["hauteur"]*Cx
    ky = (1/2)*rho*(voiture["largeur"]*voiture["longueur"]+0.8*ailerons)*Cz
    
    # Tant qu'on ne touche pas le sol
    while not distancey<0:
        vitesseX1=vitesseX
        t+=pas
        
        FtotaleX = (kx*vitesseX**2)
        vitesseX=vitesseX+(FtotaleX/mvoiture)*pas
        distancex+=vitesseX*pas
        X3.append(distancex)
        
        FtotaleY = (ky*vitesseY**2)
        vitesseY=vitesseY+((FtotaleY/mvoiture)-g)*pas
        distancey+=vitesseY*pas
        Y3.append(distancey)
        
    plt.plot(X3,Y3,color = (0,0,1))
    plt.xlabel("x (m)")
    plt.ylabel("y (m)")
    plt.title("Trajectoire de la voiture lors de l'étape n°3")
    plt.grid()
    plt.axis([0,X3[-1]+0.1,0,1])
    plt.show()
    if X3[-2]<9:
        return None,None,None
    
    print("Le temps final pour l'étape 3 est de : "+str(t-pas))
    print("La vitesse finale pour l'étape 3 est de : "+str(vitesseX))
    return vitesseX1,t-pas,distancex-9-vitesseX1*pas

Graphique de la trajectoire de la voiture :

Le graphique concerne uniquement la Nissan car il change selon la voiture.

Exemple :

En exemple, on calcule avec la Nissan qui ne dispose d’aucun équipement.

Ravin(Nissan,0.0001,Looping(Nissan,Pente(Nissan,0.0001)[0],0.0001)[0])

Le temps final pour l'étape 3 est de : 0.4514999999999666
La vitesse finale pour l'étape 3 est de : 20.40772995771356

Calcul de la vitesse minimale à la sortie du looping pour franchir le ravin :

#Trouver la vitesse minimum pour franchir le Ravin (ici pour la Nissan)
def trouverx():
    v=21
    bon= Ravin(Nissan,0.001,v)[0] # Etape avec quelle voiture pour vérifier son minimum
    while bon!=None:
        v=v-0.001
        
        # Etape avec quelle voiture pour vérifier son minimum
        bon = Ravin(Nissan,0.001,v)[0]
        
    return v

print(trouverx())

19.985999999993872

En conclusion, chaque voiture possède une vitesse minimale à la sortie du looping pour pouvoir franchir le ravin. La Nissan doit avoir une vitesse supérieure ou égale à 19.986 m/s pour pouvoir le franchir.

Étape 4 : Piste d’arrivée

Forces et Repères :

Équations du mouvement :

Projection sur l’axe $x$ :
( $x <=> \vec i$ )

$a_x = \frac{-r-f+Fm}m = \frac{-r-f}m+a_m$
Donc : $v'_x = \frac{-r-f+Fm}m$

Équation différentielle:
Avec $r = (1/2⋅ρ⋅S⋅C_x⋅v^2)$

Projection sur l’axe $y$ :
( $y <=> \vec j$ )

$a_y = 0$
Donc : $v'_y = 0$

Alors : $N = -P$

En conclusion, la vitesse finale sera uniquement celle de la résolution de l’équation $v'_x$.

Calculs :

Code Python :

# Etape 4 pour l'arrivée
def Arrivee(voiture,pas,vitessei,distancex,ailerons= 0,jupe = 0,booster = 0):
# Initialisation des variables si on utilise les accessoires d'amélioration

    # Initialisation de variables
    distance = distancex
    t=0
    
    # Coefficient de trainée
    Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
    
    # Initialisation de variables
    mvoiture=voiture["masse"]+ailerons*30+jupe*15
    accvoiture=voiture["accm"]+((voiture["accm"]*30)/100)*booster
    
    # Forces
    k = -(1/2)*rho*voiture["largeur"]*voiture["hauteur"]*Cx
    N = mvoiture*g
    frottement = N*u
 
    # Tant qu'on arrive pas à la ligne d'arrivée
    while not distance>=10:
        t += pas
        Ftotale = (k*vitessei**2)-frottement
        vitessei=vitessei + ((Ftotale/mvoiture) + accvoiture)*pas
        distance += vitessei*pas
        
    print("Le temps final pour l'étape 4 est de : "+str(t))
    print("La vitesse finale pour l'étape 4 est de : "+str(vitessei))
    return vitessei,t

Exemple :

En exemple, on calcule avec la Nissan qui ne dispose d’aucun équipement.

Arrivee(Nissan,0.0001,Ravin(Nissan,0.0001,Looping(Nissan,Pente(Nissan,0.0001)[0],0.0001)[0])[0],Ravin(Nissan,0.0001,Looping(Nissan,Pente(Nissan,0.0001)[0],0.0001)[0])[2])

Le temps final pour l'étape 4 est de : 0.4551999999999662
La vitesse finale pour l'étape 4 est de : 22.528390857814273

Circuit complet

Schéma du circuit :

Calculs :

Code Python :

import math as m
import matplotlib.pyplot as plt

# Etape pour la pente
def Pente(voiture,pas,ailerons=0,jupe = 0,booster = 0): 
# Initialisation des variables si on utilise les accessoires d'amélioration

    # Initilialisation de variables
    vitessei=0
    alpha=3.70*(m.pi/180)
    distance = 0
    t=0
    
    # Coefficient de trainée
    Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
    
    # Initialisation de variables
    mvoiture=voiture["masse"]+ailerons*30+jupe*15
    accvoiture=voiture["accm"]+((voiture["accm"]*30)/100)*booster
    
    # Forces 
    poids = (mvoiture*g*m.sin(alpha))
    k = -(1/2)*rho*(voiture["largeur"]*voiture["hauteur"])*Cx
    N = (m.cos(alpha) *mvoiture*g)
    frottement = N*u
    
    force_constante=poids-frottement
    
    # Tant qu'on arrive pas au bout de notre pente
    while not distance>=31:
        t += pas
        Ftotale = (k*vitessei**2)+force_constante
        vitessei = vitessei + ((Ftotale/mvoiture) + accvoiture)*pas
        # Réecriture de l'équation différentielle avec la méthode d'Euler
        distance += vitessei*pas
        
    vitesse_finale = vitessei
    temps_final = t 
    
    print("Le temps final pour l'étape 1 est de : "+str(temps_final))
    print("La vitesse finale pour l'étape 1 est de : "+str(vitesse_finale))
    
    return vitesse_finale,temps_final

# Etape 2 pour le looping
def Looping(voiture, vitessei, pas, ailerons=0,jupe=0, booster=0):
# Initialisation des variables si on utilise les accessoires d'amélioration

    # Initialisation des listes
    x2 = [0]
    y2 = [0]
    t = [0]
    
    # Paramètres de la voiture et de l'environnement
    L = 6  # Rayon du looping
    w = [vitessei / L]  # Vitesse angulaire initiale
    theta = [0]  # Angle initial
    
    # Coefficient de trainée
    Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
    
    # Initialisation de variables
    mvoiture = voiture["masse"]+ailerons*30+jupe*15
    accvoiture = voiture["accm"]+((voiture["accm"]*30)/100)*booster
    
    # Forces
    k = (1/2)*rho*voiture["largeur"]*voiture["hauteur"]*Cx  
    P = mvoiture * g

    # Tant qu'on a pas fait le tour du cercle
    while theta[-1] < 2 * m.pi: 
        # Mise à jour du pas
        t.append(t[-1] + pas)
        nouveau_theta = theta[-1] + (pas * w[-1])
        
        # Sépération de plusieurs équations 
        Ftotale1 = -(k*(w[-1]**2)*(L**2))
        Ftotale2 = -(u*(P*m.cos(theta[-1])+L*(w[-1]**2)*mvoiture))
        Ftotale3 = -(P*m.sin(theta[-1]))
        
        # Rassemblement des équations
        FtotaleF = Ftotale1 + Ftotale2 + Ftotale3
        
        # Calcul de l'accélération angulaire
        acceleration_angulaire = (accvoiture/L) + FtotaleF/(mvoiture * L)
        
        # Calcul de la nouvelle vitesse angulaire
        nouvelle_vitesse_angulaire = w[-1] + (pas * acceleration_angulaire)
        
        # Mise à jour des listes
        theta.append(nouveau_theta)
        w.append(nouvelle_vitesse_angulaire)
        
        # Calcul en fonction de la force qui nous tire vers le bas 
        vitesse_decrochage = m.sqrt(g*L*abs(m.cos(theta[-1])))
        
        v = w[-1] * L
        
        if v < vitesse_decrochage :
            print("Decrochage")
            plt.figure()
            plt.plot(x2, y2)
            plt.xlabel("x (m)")
            plt.ylabel("y (m)")
            plt.title("Trajectoire de la voiture")
            plt.axis([-L, L, 0, 2 * L])
            plt.grid()
            plt.show()
            
            # Graphique de la vitesse
            v = [wi * L for wi in w]  
            # Reprise de toutes les valeures !
            
            plt.figure()
            plt.plot(t, v)
            plt.xlabel("Temps (s)")
            plt.ylabel("Vitesse (m/s)")
            plt.title("Vitesse en fonction du temps")
            plt.grid()
            plt.show()
            return None,None
        distance = v * pas
        
        # Gestion des coordonnées X et Y
        x2.append(x2[-1] + m.cos(nouveau_theta) * distance)
        y2.append(y2[-1] + m.sin(nouveau_theta) * distance)
    
    # Graphique de la trajectoire
    plt.figure()
    plt.plot(x2, y2,color = (1,0,1))
    plt.xlabel("x (m)")
    plt.ylabel("y (m)")
    plt.title("Trajectoire de la voiture")
    plt.axis([-L, L, 0, 2 * L])
    plt.grid()
    plt.show()
    
    # Graphique de la vitesse
    v = [wi * L for wi in w]  
    # Reprise de toutes les valeures pour la vitesse grâce à la liste w
    
    plt.plot(t, v,color = (0,0,1))
    plt.xlabel("Temps (s)")
    plt.ylabel("Vitesse (m/s)")
    plt.title("Vitesse en fonction du temps")
    plt.grid()
    plt.show()
    print("Le temps final pour l'étape 2 est de : "+str(t[-1]))
    print("La vitesse finale pour l'étape 2 est de : "+str(v[-1]))
    return v[-1], t[-1]

# Etape 3 pour le ravin
def Ravin(voiture,pas,vitessei,ailerons=0,jupe = 0):
# Initialisation des variables si on utilise les accessoires d'amélioration

    # Initialisation des listes
    X3=[0]
    Y3=[1]
    
    # Initialisation de variables
    distancex = 0
    distancey=1
    vitesseX=vitessei
    vitesseX1=vitesseX
    vitesseY=0
    t=0
    
    # Coefficient de trainée
    Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
    
    # Coefficient de portance
    Cz=0.3 +0.03*ailerons
    
    # Initialisation de variables
    mvoiture=voiture["masse"]+ailerons*30+jupe*15
    
    # Forces
    kx = -(1/2)*rho*voiture["largeur"]*voiture["hauteur"]*Cx
    ky = (1/2)*rho*(voiture["largeur"]*voiture["longueur"]+0.8*ailerons)*Cz
    
    # Tant qu'on ne touche pas le sol
    while not distancey<0:
        vitesseX1=vitesseX
        t+=pas
        
        FtotaleX = (kx*vitesseX**2)
        vitesseX=vitesseX+(FtotaleX/mvoiture)*pas
        distancex+=vitesseX*pas
        X3.append(distancex)
        
        FtotaleY = (ky*vitesseY**2)
        vitesseY=vitesseY+((FtotaleY/mvoiture)-g)*pas
        distancey+=vitesseY*pas
        Y3.append(distancey)
        
    plt.plot(X3,Y3,color = (0,0,1))
    plt.xlabel("x (m)")
    plt.ylabel("y (m)")
    plt.title("Trajectoire de la voiture lors de l'étape n°3")
    plt.grid()
    plt.axis([0,X3[-1]+0.1,0,1])
    plt.show()
    if X3[-2]<9:
        return None,None,None
    
    print("Le temps final pour l'étape 3 est de : "+str(t-pas))
    print("La vitesse finale pour l'étape 3 est de : "+str(vitesseX))
    return vitesseX1,t-pas,distancex-9-vitesseX1*pas

# Etape 4 pour l'arrivée
def Arrivee(voiture,pas,vitessei,distancex,ailerons= 0,jupe = 0,booster = 0):
# Initialisation des variables si on utilise les accessoires d'amélioration

    # Initialisation de variables
    distance = distancex
    t=0
    
    # Coefficient de trainée
    Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
    
    # Initialisation de variables
    mvoiture=voiture["masse"]+ailerons*30+jupe*15
    accvoiture=voiture["accm"]+((voiture["accm"]*30)/100)*booster
    
    # Forces
    k = -(1/2)*rho*voiture["largeur"]*voiture["hauteur"]*Cx
    N = mvoiture*g
    frottement = N*u
 
    # Tant qu'on arrive pas à la ligne d'arrivée
    while not distance>=10:
        t += pas
        Ftotale = (k*vitessei**2)-frottement
        vitessei=vitessei + ((Ftotale/mvoiture) + accvoiture)*pas
        distance += vitessei*pas
        
    print("Le temps final pour l'étape 4 est de : "+str(t))
    print("La vitesse finale pour l'étape 4 est de : "+str(vitessei))
    return vitessei,t

# Circuit complet
def Circuit(voiture,pas,ailerons=0,jupe = 0,booster = 0,etapebooster=0):

    # Vérification
    assert(ailerons==0 or ailerons==1),"1 si vous voulez mettre l'ailerons,0 sinon." 
    assert(jupe==0 or jupe==1),"1 si vous voulez mettre la jupe,0 sinon." 
    assert(booster==0 or booster==1),"1 si vous voulez utiliser le booster,0sinon." 
    assert((etapebooster==0 and booster==0) or ((etapebooster==1 or etapebooster==2 or etapebooster==4 )and booster==1)),"0 si le booster n'est pas utiliser,sinon 1 ;2;4 cela là où vous souahitez l'utilisé. "
    
    # Initialisation des variables
    vitesse=0
    temps_total=0
    t_temp=0

    # Gestion des boosters
    if etapebooster==1:
        vitesse,temps_total=Pente(voiture,pas,ailerons,jupe,1)
        vitesse,t_temp=Looping(voiture, vitesse, pas, ailerons,jupe,0)
        if vitesse==None:
            return "insuffisante looping",-1
        temps_total+=t_temp
        vitesse,t_temp,distance=Ravin(voiture,pas,vitesse,ailerons,jupe)
        if vitesse==None:
            return "insuffisante ravin",-1
        temps_total+=t_temp
        vitesse,t_temp=Arrivee(voiture,pas,vitesse,distance,ailerons,jupe,0)
        return vitesse,temps_total+t_temp,"Victoire"
    
    if etapebooster==2:
        vitesse,temps_total=Pente(voiture,pas,ailerons,jupe,0)
        vitesse,t_temp=Looping(voiture, vitesse, pas, ailerons,jupe,1)
        if vitesse==None:
            return "insuffisante looping",-1
        temps_total+=t_temp
        vitesse,t_temp,distance=Ravin(voiture,pas,vitesse,ailerons,jupe)
        if vitesse==None:
            return "insuffisante ravin",-1
        temps_total+=t_temp
        vitesse,t_temp=Arrivee(voiture,pas,vitesse,distance,ailerons,jupe,0)
        return vitesse,temps_total+t_temp,"Victoire"
    
    if etapebooster==4:
        vitesse,temps_total=Pente(voiture,pas,ailerons,jupe,0)
        vitesse,t_temp=Looping(voiture, vitesse, pas, ailerons,jupe,0)
        if vitesse==None:
            return "insuffisante looping",-1
        temps_total+=t_temp
        vitesse,t_temp,distance=Ravin(voiture,pas,vitesse,ailerons,jupe)
        if vitesse==None:
            return "insuffisante ravin",-1
        temps_total+=t_temp
        vitesse,t_temp=Arrivee(voiture,pas,vitesse,distance,ailerons,jupe,1)
        return vitesse,temps_total+t_temp,"Victoire"
    
    vitesse,temps_total=Pente(voiture,pas,ailerons,jupe,0)
    vitesse,t_temp=Looping(voiture, vitesse, pas, ailerons,jupe,0)
    if vitesse==None:
        return "insuffisante looping",-1
    temps_total+=t_temp
    vitesse,t_temp,distance=Ravin(voiture,pas,vitesse,ailerons,jupe)
    if vitesse==None:
        return "insuffisante ravin",-1
    temps_total+=t_temp
    vitesse,t_temp=Arrivee(voiture,pas,vitesse,distance,ailerons,jupe,0)
    return vitesse,temps_total+t_temp,"Victoire"
        
# Trouver la vitesse minimum pour franchir le ravin ou le looping
# Ici, on a choisi la Nissan dans le ravin mais on peut changer
def trouverx():
    v=21
    bon= Ravin(Nissan,0.001,v)[0] # Etape avec quelle voiture pour vérifier son minimum
    while bon!=None:
        v=v-0.001
        
        # Etape avec quelle voiture pour vérifier son minimum
        bon = Ravin(Nissan,0.001,v)[0]
        
    return v
    
u=0.1 #coefficient de frottement
g=9.81 #constante gravitationnelle
rho=1.293 # Masse volumique de l'air à 20°C

# Initialisation des dictionnaires
Dodge={"masse":1760,"accm":5.1,"longueur":5.28,"largeur":1.95,"hauteur":1.35,"trainee":0.38}
Toyota={"masse":1615,"accm":5.4,"longueur":4.51,"largeur":1.81,"hauteur":1.27,"trainee":0.29}
Chevrolet={"masse":1498,"accm":5.3,"longueur":4.72,"largeur":1.88,"hauteur":1.3,"trainee":0.35}
Mazda={"masse":1385,"accm":5.2,"longueur":4.3,"largeur":1.75,"hauteur":1.23,"trainee":0.28}
Nissan={"masse":1540,"accm":5.8,"longueur":4.6,"largeur":1.79,"hauteur":1.36,"trainee":0.34}
Mitsubishi={"masse":1600,"accm":5,"longueur":4.51,"largeur":1.81,"hauteur":1.48,"trainee":0.28}

Résultat :

Dodge sans équipement :

print("Résultat pour la Dodge")
print(Circuit(Dodge,0.0001,0,0,0,0)) 
print("vitesse_finale , temps_total , Course terminé ? ")

Résultat pour la Dodge
Le temps final pour l'étape 1 est de : 3.618100000003211
La vitesse finale pour l'étape 1 est de : 17.070908072743308
Le temps final pour l'étape 2 est de : 2.616000000001096
La vitesse finale pour l'étape 2 est de : 19.422966784313846
('insuffisante ravin', -1)
vitesse_finale , temps_total , Course terminé ?

Dodge avec équipements :

print("Résultat pour la Dodge")
print(Circuit(Dodge,0.0001,1,1,1,1)) # Version la plus rapide de la Dodge
print("vitesse_finale , temps_total , Course terminé ? ")

Résultat pour la Dodge
Le temps final pour l'étape 1 est de : 3.146600000002216
La vitesse finale pour l'étape 1 est de : 19.63515819709627
Le temps final pour l'étape 2 est de : 2.306500000000443
La vitesse finale pour l'étape 2 est de : 20.091094834320813
Le temps final pour l'étape 3 est de : 0.4514999999999666
La vitesse finale pour l'étape 3 est de : 20.029237790536214
Le temps final pour l'étape 4 est de : 0.4741999999999641
La vitesse finale pour l'étape 4 est de : 21.911447129182502
(21.911447129182502, 6.378800000002589, 'Victoire')
vitesse_finale , temps_total , Course terminé ?

Nissan sans équipement :

print("Résultat pour la Nissan")
print(Circuit(Nissan,0.0001,0,0,0,0))
print("vitesse_finale , temps_total , Course terminé ? ")

Résultat pour la Nissan
Le temps final pour l'étape 1 est de : 3.3776000000027033
La vitesse finale pour l'étape 1 est de : 18.290174142188583
Le temps final pour l'étape 2 est de : 2.364400000000565
La vitesse finale pour l'étape 2 est de : 20.47329242593228
Le temps final pour l'étape 3 est de : 0.4514999999999666
La vitesse finale pour l'étape 3 est de : 20.40772995771356
Le temps final pour l'étape 4 est de : 0.4551999999999662
La vitesse finale pour l'étape 4 est de : 22.528390857814273
(22.528390857814273, 6.648700000003201, 'Victoire')
vitesse_finale , temps_total , Course terminé ?

Nissan avec équipements :

print("Résultat pour la Nissan")
print(Circuit(Nissan,0.0001,1,1,1,1)) # Version la plus rapide de la Nissan
print("vitesse_finale , temps_total , Course terminé ? ")

Résultat pour la Nissan
Le temps final pour l'étape 1 est de : 2.940500000001781
La vitesse finale pour l'étape 1 est de : 21.014712319683287
Le temps final pour l'étape 2 est de : 2.1078000000000237
La vitesse finale pour l'étape 2 est de : 21.19503346594931
Le temps final pour l'étape 3 est de : 0.4514999999999666
La vitesse finale pour l'étape 3 est de : 21.13016629254108
Le temps final pour l'étape 4 est de : 0.4268999999999693
La vitesse finale pour l'étape 4 est de : 23.12033687967721
(23.12033687967721, 5.92670000000174, 'Victoire')
vitesse_finale , temps_total , Course terminé ?

Comparaison des valeurs obtenues

On ne compare que la Dodge et la Nissan car la Nissan est la voiture la plus rapide et la Dodge est la voiture de prédilection de Dom Torreto.

Pour pouvoir effectuer les comparaisons, on utilise les données des voitures avec leur version la plus rapide.

Vitesse à la fin de la pente :

Vitesse de la Dodge $\approx$ 19.635 m/s
Vitesse de la Nissan $\approx$ 21.015 m/s
Différence : 1.380 m/s

La Nissan est environ 1.380 m/s plus rapide que la Dodge.

Vitesse minimale à l’entrée du looping pour le réussir :

Vitesse minimale de la Dodge $\approx$ 13.526 m/s
Vitesse minimale de la Nissan $\approx$ 12.315 m/s
Différence : 1.211 m/s

La Dodge doit avoir une vitesse d’entrée plus importante que celle de la Nissan (ici, environ 1.211 m/s de plus) pour pouvoir réussir le looping.

Vitesse à la fin du looping :

Vitesse de la Dodge $\approx$ 20.091 m/s
Vitesse de la Nissan $\approx$ 21.195 m/s
Différence : 1.104 m/s

La Nissan est environ 1.104 m/s plus rapide que la Dodge.

Vitesse minimale à la sortie du looping pour réussir le saut :

Vitesse minimale de la Dodge $\approx$ 19.986 m/s
Vitesse minimale de la Nissan $\approx$ 19.986 m/s
Différence : 0 m/s

La Dodge et la Nissan doivent avoir une vitesse minimum d’environ 19.986 m/s à la sortie du looping pour pouvoir réussir le saut.

Vitesse à la fin du circuit :

Vitesse de la Dodge $\approx$ 21.911 m/s
Vitesse de la Nissan $\approx$ 23.120 m/s
Différence : 1.209 m/s

La Nissan finit la course avec une vitesse supérieure à la Dodge de 1.209 m/s.

Temps effectué :

Temps de la Dodge $\approx$ 6.379 s
Temps de la Nissan $\approx$ 5.927 s
Différence : 0.452 s

La Nissan finit la course avec un temps inférieur à la Dodge de 0.452 s.

Critiques :

Malgré avoir trouvé des résultats, ils ne sont pas fiables à 100% car la surface utilisée pour les voitures n’est pas parfaite. Nous avons calculer la surface des voitures comme des rectangles, ce qui n’est pas réellement vrai. Ensuite, nous avons négligé la vitesse de l’air ainsi que les conditions météorologique car elles n’influaient pas beaucoup les résultats. Cependant, on peut dire que nos calculs de chaque étape sont cohérents.

Conclusion

En conclusion, nous avons pu déterminer que la Nissan était la voiture la plus rapide pour remporter la course, qu’elle soit équipée ou non.

Cependant, la Dodge avec des équipements comme un booster à l’étape 1, une jupe frontale et des ailerons de surfaces peut aussi gagner. En effet, la voiture de prédilection de Dom Torreto est moins rapide que la Nissan mais elle est plus rapide que celle de Tej Parker.

Tej parker parcourt le circuit en environ 8 secondes, alors que la Dodge peut le parcourir en environ 6,379 secondes. Puis la Nissan avec les mêmes équipements, en environ 5,927 secondes.

Dom Torreto a donc le choix d’effectuer la course avec la Nissan ou alors avec sa Dodge.